__DefBitFieldType FullITypes<3>
  S8;
  U8;
  S16;
  U16;
  S32;
  U32;
  S64;
  U64;

__DefBitFieldType FullITypesNoI64<3>
  S8;
  U8;
  S16;
  U16;
  S32;
  U32;

__DefBitFieldType I8Types<1>
  S8;
  U8;

__DefBitFieldType FTypes<2>
  F64;
  F32;
  F16;
  BF16;

__DefBitFieldType FTypesNoF64<2>
  F32;
  F16;
  BF16;

__DefBitFieldType F2IRnd<2>
  ROUND;
  CEIL;
  FLOOR;
  TRUNC;

__DefBitFieldType F2INTZ<1>
  NoNTZ;
  NTZ;

__DefBitFieldType F64F32F16<2>
  F64;
  F32;
  F16;

__DefBitFieldType F32F16<2>
  F32;
  F16;

__DefBitFieldType F64Only<2>
  F64=0x2;

// TODO:
__DefBitFieldType VSel<2>
  S0;
  S1;
  S2;
  S3;

// F2FP.BF16.E8
// F2FP.BF16.F32
// F2FP.E2M1.F32
// F2FP.E2M3.F32
// F2FP.E3M2.F32
// F2FP.E4M3.F16
// F2FP.E4M3.F32
// F2FP.E5M2.F16
// F2FP.E5M2.F32
// F2FP.E8.BF16
// F2FP.E8.F32
// F2FP.F16.E2M1
// ** F2FP.BF16.E2M1
// F2FP.F16.E2M3
// F2FP.F16.E3M2
// F2FP.F16.E4M3
// F2FP.F16.E5M2
// F2FP.F16.F32
// F2FP.TF32.F32
__DefBitFieldType F2FPSrcType<4>
  F32;
  F16;
  BF16;
  E5M2;
  E4M3;
  E8;
  E3M2;
  E2M3;
  E2M1;

__DefBitFieldType F2FPDstType<4>
  TF32;
  F16;
  BF16;
  E5M2;
  E4M3;
  E8;
  E3M2;
  E2M3;
  E2M1;

__DefBitFieldType SATFINITE<1>
    NoSATFINITE;
    SATFINITE;

__DefGroup CVT : [ALL]
  __Encoding
    field<12,  3> Pred pg=PT;
    field<15,  1> PModi pg.not=False;
    field<16,  8> Reg rd;

// I2F, F2I, F2F, FRND, I2FP, F2IP, F2FP

__DefOptype I2F : [CVT]
  __Encoding
    field<0,  8> Optype optype==I2F;
    field<78, 2> FPRound rnd=RN;
    field<88, 2> FTypesNoF64 ftype=F32;
    field<92, 3> FullITypesNoI64 itype=S32;

  __Syntax
```asm          
I2F{.ftype}{.itype}.rnd Rd, SrcB{.vsel}      $sched $req ;

.ftype = {.F32*, .F16, .BF16}
.itype = {.S8, .U8, .S16, .U16, .S32*, .U32}
.rnd = {.RN*, .RP, .RM, .RZ}
.vsel = {.B0, .B1, .B2, .B3, .H0, .H1}
```

  __Description
将输入整数类型转换为浮点数。

  __OperandInfo
Rd必须来源于GPR。

SrcB的来源可以是GPR、UR或cmem。

当输入整数类型位宽小于32时，SrcB可以添加一个后缀修饰符.vsel，用于选择32bit输入中的特定bit作为操作数：
- 输入整数类型为.S8/.U8时，.vsel可以取.B0（默认值）、.B1、.B2或.B3，分别用于选择32bit输入中的不同字节（.B0用于选择最低字节，.B3用于选择最高字节，以此类推）
- 输入整数类型为.S16/.U16时，.vsel可以取.H0（默认值）或.H1，分别用于选择32bit输入的低16bit或高16bit

  __ModifierInfo
.ftype可以是.F32（默认值，可省略）、.F16或.BF16，表示输出浮点数的类型。

.itype可以是.S8、.U8、.S16、.U16、.S32（默认值，可省略）或.U32，表示输入整数的类型。

.rnd可取.RN（默认值，可省略）、.RP、.RM和.RZ，表示转换过程的舍入模式：

| .rnd  | 舍入模式 |
|:--:|:---|
|.RN | 尾数四舍五入 |
|.RP | 尾数向正无穷方向舍入 |
|.RM | 尾数向负无穷方向舍入 |
|.RZ | 尾数向零（原点）舍入 |

  __Semantics
```asm
I2F.ftype.itype.rnd Rd, SrcB.vsel:
    if (.itype == .S16 || .itype == .U16) {
        // 将32bit输入SrcB拆分为两个16bit，h1在高位，h0在低位
        {h1, h0} = SrcB;
        // 根据.vsel选择输入
        if (.vsel == .H0) {
            b = h0;
        } else {
            b = h1;
        }
    } else if (.itype == .S8 || .itype == .U8) {
        // 将32bit输入SrcB拆分为4个byte，b3在最高位，b0在最低位
        {b3, b2, b1, b0} = SrcB;
        // 根据.vsel选择输入
        switch (.vsel) {
            case .B0: b = b0; break;
            case .B1: b = b1; break;
            case .B2: b = b2; break;
            case .B3: b = b3; break;
        }
    } else {
        b = SrcB;
    }
    // 根据舍入模式和目的数据类型，执行转换
    Rd = cvtInt2Float(b, .ftype, .rnd);
```

__Examples
```asm
I2F R0, R1;         // I2F.32 R0, R1也可以，表示R0 = R1
I2F R0, 0x114514;   // R0 = 0x114514
I2F.64 R[0:1], R[2:3]; // R[0:1] = R[2:3]
```

__DefOpcode I2F_R : [I2F]
  __Encoding
    field<8,  4> SType stype==R;
    field<32, 8> Reg rb;
    field<82, 2> VSel rb.vsel=S0;
  __OperandInfo
    InList<pg, rb>;
    OutList<rd>;
    Order<pg, rd, rb>;
    Bitwidth<rd> = 32;
    Bitwidth<rb> = 32;
    AsmFormat<rb.vsel> = CvtVSel(rb.vsel, itype);
  __Exception
    EncodingError<IllegalBitFieldCombination, "Invalid vsel for 16bit itype (Valid values: S0, S1)."> = ((itype=="S16") or (itype=="U16")) and ((rb.vsel=="S2") or (rb.vsel=="S3"));
    EncodingError<IllegalBitFieldCombination, "Invalid vsel for 32bit itype (Valid values: S0)."> = ((itype=="S32") or (itype=="U32")) and (rb.vsel!="S0");

__DefOpcode I2F_C : [I2F]
  __Encoding
    field<8,  4> SType stype==C;
    field<32, 22> CMem vb;
    field<82, 2> VSel vb.vsel=S0;
  __OperandInfo
    InList<pg, vb>;
    OutList<rd>;
    Order<pg, rd, vb>;
    Bitwidth<rd> = 32;
    Bitwidth<vb> = 32;
    AsmFormat<vb.vsel> = CvtVSel(vb.vsel, itype);
  __Exception
    EncodingError<IllegalBitFieldCombination, "Invalid vsel for 16bit itype (Valid values: S0, S1)."> = ((itype=="S16") or (itype=="U16")) and ((vb.vsel=="S2") or (vb.vsel=="S3"));
    EncodingError<IllegalBitFieldCombination, "Invalid vsel for 32bit itype (Valid values: S0)."> = ((itype=="S32") or (itype=="U32")) and (vb.vsel!="S0");

__DefOpcode I2F_U : [I2F]
  __Encoding
    field<8,  4> SType stype==U;
    field<32, 6> UReg urb;
    field<82, 2> VSel urb.vsel=S0;
  __OperandInfo
    InList<pg, urb>;
    OutList<rd>;
    Order<pg, rd, urb>;
    Bitwidth<rd> = 32;
    Bitwidth<urb> = 32;
    AsmFormat<urb.vsel> = CvtVSel(urb.vsel, itype);
  __Exception
    EncodingError<IllegalBitFieldCombination, "Invalid vsel for 16bit itype (Valid values: S0, S1)."> = ((itype=="S16") or (itype=="U16")) and ((urb.vsel=="S2") or (urb.vsel=="S3"));
    EncodingError<IllegalBitFieldCombination, "Invalid vsel for 32bit itype (Valid values: S0)."> = ((itype=="S32") or (itype=="U32")) and (urb.vsel!="S0");

__DefOptype F2F : [CVT]
  __Encoding
    field<0,  8> Optype optype==F2F;
    field<76,  1> FPFtz ftz = NoFTZ;
    field<78,  2> FPRound rnd = RN;
    field<88,  2> FTypesNoF64 dsttype;
    field<92,  2> FTypesNoF64 srctype;

  __Syntax
```asm          
F2F.dsttype.srctype{.FTZ}{.rnd} Rd, {-}{|}SrcB{.hsel}{|}      $sched $req ;

.dsttype = {.F32, .F16, .BF16}
.srctype = {.F32, .F16, .BF16}
.rnd = {.RN*, .RP, .RM, .RZ}
.hsel = {.H0*, .H1}
```

  __Description
将srctype类型的输入浮点数SrcB转换为dsttype类型的浮点数Rd。

  __OperandInfo
    ModiOrder<dsttype, srctype>;

Rd必须来源于GPR。

SrcB的来源可以是GPR、UR或cmem。

SrcB可以添加3种可选的修饰符（可共存）：

- 负号前缀（-）：表示对SrcB取相反数作为输入。
- 绝对值（|*|）：表示取SrcB的绝对值作为输入。
- bit field选择（.hsel）：仅当.srctype = .F16或.BF16时生效，可取值为.H0或.H1，分别表示从SrcB的32bit中提取低16bit或高16bit作为输入。

SrcB同时存在多种修饰符时，按照：先.hsel，再取绝对值，最后取相反数的优先级次序与SrcB结合。

  __ModifierInfo
.dsttype可取值包括.F32、.F16、.BF16，分别表示将SrcB转换为F32、F16或是BF16格式的浮点数Rd。

.srctype可取值包括.F32、.F16、.BF16，分别表示将源操作数SrcB视为F32、F16或是BF16格式的浮点数。

可选修饰符.FTZ表示如果输入/输出中出现了非规格化浮点数（subnormal number），则将其转换为有符号0（即保持符号位不变，其他bit全部置0）。

.rnd可取值包括.RN（默认可省略）、.RP、.RM和.RZ，分别表示舍入模式为最近舍入、向正无穷方向舍入、向负无穷方向舍入和向零舍入。

  __Semantics
```asm
F2F.dsttype.srctype.ftz.rnd Rd, SrcB.hsel:
    if (.srctype == .F16 || .srctype == .BF16) {
        // 将32bit输入SrcB拆分为两个16bit，h1在高位，h0在低位
        {h1, h0} = SrcB;
        // 根据.hsel选择输入
        if (.hsel == .H0) {
            b = h0;
        } else {
            b = h1;
        }
    } else {
        b = SrcB;
    }
    // 将b转换为指定格式的浮点数，根据需要进行附加处理
    Rd = cvtFP2FP(b, .dsttype, .ftz, .rnd);
```

  __Examples
```asm
F2F.F16.F32 R0, -|R1|;
F2F.F32.BF16.RZ R0, R1.H1;
```

  __Exception
    EncodingError<IllegalBitFieldCombination, "F2F dst should not be the same with src."> = dsttype == srctype;


__DefOpcode F2F_R : [F2F]
  __Encoding
    field<8,  4> SType stype==R;
    field<32, 8> Reg rb;
    field<96, 1> SignModi rb.neg=False;
    field<97, 1> SignModi rb.abs=False;

    field<82, 1> HSel rb.hsel=H0;
  __OperandInfo
    InList<pg, rb>;
    OutList<rd>;
    Order<pg, rd, rb>;
    Bitwidth<rd> = 32;
    Bitwidth<rb> = 32;
  __Exception
    EncodingError<IllegalBitFieldCombination, "Invalid hsel for F2F with srctype=F32."> = (srctype=="F32") and (rb.hsel=="H1");

__DefOpcode F2F_U : [F2F]
  __Encoding
    field<8,  4> SType stype==U;
    field<32, 6> UReg urb;
    field<96, 1> SignModi urb.neg=False;
    field<97, 1> SignModi urb.abs=False;

    field<82, 1> HSel urb.hsel=H0;
  __OperandInfo
    InList<pg, urb>;
    OutList<rd>;
    Order<pg, rd, urb>;
    Bitwidth<rd>  = 32;
    Bitwidth<urb> = 32;

  __Exception
    EncodingError<IllegalBitFieldCombination, "Invalid hsel for F2F with srctype=F32."> = (srctype=="F32") and (urb.hsel=="H1");

__DefOpcode F2F_C : [F2F]
  __Encoding
    field<8,  4> SType stype==C;
    field<32, 22> CMem vb;
    field<96, 1> SignModi vb.neg=False;
    field<97, 1> SignModi vb.abs=False;

    field<82,  1> HSel vb.hsel=H0;
  __OperandInfo
    InList<pg, vb>;
    OutList<rd>;
    Order<pg, rd, vb>;
    Bitwidth<rd> = 32;
    Bitwidth<vb> = 32;

  __Exception
    EncodingError<IllegalBitFieldCombination, "Invalid hsel for F2F with srctype=F32."> = (srctype=="F32") and (vb.hsel=="H1");

__DefOptype F2I : [CVT]
  __Encoding
    field<0,  8> Optype optype==F2I;
    field<76, 1> FPFtz ftz=NoFTZ;
    field<77, 1> F2INTZ ntz=NoNTZ;
    field<78, 2> F2IRnd rnd=ROUND;
    // field<80, 1> FPSat  sat=NoSAT;

    field<88, 3> FullITypesNoI64 itype=S32;
    field<92, 2> FTypesNoF64 ftype=F32;

  __Syntax
```asm          
F2I.itype.ftype{.FTZ}{.NTZ}{.rnd} Rd, {-}{|}SrcB{.hsel}{|}      $sched $req ;

.itype = {.S8, .U8, .S16, U16, S32*, .U32}
.ftype = {.F32*, .F16, .BF16}
.rnd = {.ROUND*, .CEIL, .FLOOR, .TRUNC}
.hsel = {.H0*, .H1}
```

  __Description
将stype类型的输入浮点数SrcB根据指定的方式转换为整数，并写入Rd。

如果转换的目的类型位宽小于32bit，根据结果的符号进行零扩展或符号扩展，以填满Rd。

  __OperandInfo
Rd必须来源于GPR。

SrcB的来源可以是GPR、UR或cmem。

SrcB可以添加3种可选的修饰符（可共存）：

- 负号前缀（-）：表示对SrcB取相反数作为输入。
- 绝对值（|*|）：表示取SrcB的绝对值作为输入。
- bit field选择（.hsel）：仅当.ftype = .F16或.BF16时生效，可取值为.H0或.H1，分别表示从SrcB的32bit中提取低16bit或高16bit作为输入。

SrcB同时存在多种修饰符时，按照：先.hsel，再取绝对值，最后取相反数的优先级次序与SrcB结合。

  __ModifierInfo
.itype可取值包括.S8、.U8、.S16、U16、S32（默认可省略）或.U32，分别表示将SrcB转换为何种格式的整数。

.ftype可取值包括.F32（默认可省略）、.F16、.BF16，分别表示将源操作数SrcB视为F32、F16或是BF16格式的浮点数。

.rnd可取值包括.ROUND（默认可省略）、.CEIL、.FLOOR和.TRUNC，分别表示舍入模式为：向最近的整数舍入（如果等距，向偶数舍入）、向正无穷方向舍入、向负无穷方向舍入和向零舍入。

2个可选修饰符.FTZ和.NTZ分别表示：
| Modifier | Description |
| :--- | :--- |
| .FTZ | 若SrcB为非规格化浮点数，转换为0 |
| .NTZ | 若SrcB为NAN，转换为0 |

  __Semantics
```asm
F2I.itype.ftype.ftz.ntz.rnd Rd, SrcB.hsel:
    if (.ftype == .F16 || .ftype == .BF16) {
        // 将32bit输入SrcB拆分为两个16bit，h1在高位，h0在低位
        {h1, h0} = SrcB;
        // 根据.hsel选择输入
        if (.hsel == .H0) {
            b = h0;
        } else {
            b = h1;
        }
    } else {
        b = SrcB;
    }
    // 将b转换为整数
    if (b is not NAN) {
        // 处理非规格化数
        if (.ftz == .FTZ && b is subnormal) {
            b = 0;
        }
        // 根据.rnd舍入转换为整数
        b = round2Int(b, .rnd);
        // 将结果饱和转换到.itype的最大最小值之间
        b = b > MAX(.itype) ? MAX(.itype) : b;
        b = b < MIN(.itype) ? MIN(.itype) : b;
        // 根据.itype是否有符号，将b转换为有符号/无符号32bit整数
        if (.itype is signed) {
            // 符号扩展到32bit，填满Rd寄存器
            Rd = INT32(b);
        } else {
            // 零扩展到32bit，填满Rd寄存器
            Rd = UINT32(b);
        }
    // 处理NAN输入
    } else {
        if (.ntz == .NTZ) {
            Rd[31:0] = 0x0;
        } else {
            n = sizeInBitOf(.itype);
            // 将32bit寄存器Rd的MSB置为1，其余bit置零
            Rd[31:0] = 0x80000000;
        }
    }
```

  __Examples
```asm
F2I.S16.F32 R0, -|R1|;
F2I.S32.F16.FLOOR R0, R1.H1;
```

__DefOpcode F2I_R : [F2I]
  __Encoding
    field<8,  4> SType stype==R;
    field<32, 8> Reg rb;

    field<96, 1> SignModi rb.neg=False;
    field<97, 1> SignModi rb.abs=False;

    field<82, 1> HSel rb.hsel=H0;
  __OperandInfo
    InList<pg, rb>;
    OutList<rd>;
    Order<pg, rd, rb>;
    Bitwidth<rd> = 32;
    Bitwidth<rb> = 32;

  __Exception
    EncodingError<IllegalBitFieldCombination, "Invalid hsel for F2I with srctype=F32."> = (ftype=="F32") and (rb.hsel=="H1");

__DefOpcode F2I_U : [F2I]
  __Encoding
    field<8,  4> SType stype==U;
    field<32, 6> UReg urb;

    field<96, 1> SignModi urb.neg=False;
    field<97, 1> SignModi urb.abs=False;

    field<82, 1> HSel urb.hsel=H0;
  __OperandInfo
    InList<pg, urb>;
    OutList<rd>;
    Order<pg, rd, urb>;
    Bitwidth<rd> = 32;
    Bitwidth<urb> = 32;
  __Exception
    EncodingError<IllegalBitFieldCombination, "Invalid hsel for F2I with srctype=F32."> = (ftype=="F32") and (urb.hsel=="H1");

__DefOpcode F2I_C : [F2I]
  __Encoding
    field<8,  4> SType stype==C;
    field<32, 22> CMem vb;
    field<96, 1> SignModi vb.neg=False;
    field<97, 1> SignModi vb.abs=False;

    field<82, 1> HSel vb.hsel=H0;
  __OperandInfo
    InList<pg, vb>;
    OutList<rd>;
    Order<pg, rd, vb>;
    Bitwidth<rd> = 32;
    Bitwidth<vb> = 32;
  __Exception
    EncodingError<IllegalBitFieldCombination, "Invalid hsel for F2I with srctype=F32."> = (ftype=="F32") and (vb.hsel=="H1");

__DefOptype FRND : [CVT]
  __Encoding
    field<0,  8> Optype optype==FRND;
    field<76, 1> FPFtz ftz=NoFTZ;
    field<78, 2> F2IRnd rnd=ROUND;
    field<88, 2> F32F16 ftype=F32;

  __Syntax
```asm          
FRND{.ftype}{.FTZ}{.rnd} Rd, {-}{|}SrcB{.hsel}{|}      $sched $req ;

.ftype = {.F32*, .F16}
.rnd = {.ROUND*, .CEIL, .FLOOR, .TRUNC}
.hsel = {.H0*, .H1}
```

  __Description
将ftype类型的输入浮点数SrcB根据指定的方式转换为整数，再以ftype类型的浮点数保存在Rd中。

由于输入SrcB已经是浮点数，因此取整本身不会溢出，只会得到一个浮点数。

  __OperandInfo
Rd必须来源于GPR。

SrcB的来源可以是GPR、UR或cmem。

SrcB可以添加3种可选的修饰符（可共存）：

- 负号前缀（-）：表示对SrcB取相反数作为输入。
- 绝对值（|*|）：表示取SrcB的绝对值作为输入。
- bitfield选择（.hsel）：仅当.ftype = .F16时生效，可取值为.H0或.H1，分别表示从SrcB的32bit中提取低16bit或高16bit作为输入。

SrcB同时存在多种修饰符时，按照：先.hsel，再取绝对值，最后取相反数的优先级次序与SrcB结合。

  __ModifierInfo
.ftype可取值包括.F32（默认可省略）或.F16。

.rnd可取值包括.ROUND（默认可省略）、.CEIL、.FLOOR和.TRUNC，分别表示舍入模式为：向最近的整数舍入（如果等距，向偶数舍入）、向正无穷方向舍入、向负无穷方向舍入和向零舍入。

可选修饰符.FTZ表示：若SrcB为非规格化浮点数，转换为0。

  __Semantics
如果输入浮点数操作数为NAN，该指令的输出行为参考[浮点数NAN处理规则](浮点数NAN处理规则.md)。

```asm
FRND.ftype.ftz.rnd Rd, SrcB.sel:
    if (.ftype == .F16) {
        // 将32bit输入SrcB拆分为两个16bit，h1在高位，h0在低位
        {h1, h0} = SrcB;
        // 根据.sel选择输入
        if (.sel == .H0) {
            b = h0;
        } else {
            b = h1;
        }
    } else {
        b = SrcB;
    }
    // 将b转换为整数
    if (b is not NAN && b is not +INF && b is not -INF) {
        // 处理非规格化数
        if (.ftz == .FTZ && b is subnormal) {
            b = 0;
        }
        // 根据.rnd模式，舍入转换为整数
        b = round2Int(b, .rnd);
    } else if (b is +INF || b is -INF) {
        // 保持不变
    } else {
        // 处理NAN输入
        b[31:0] = 0x7FFFFFFF
    }
    // 再次将b转换为ftype类型的浮点数
    Rd = typeof(.ftype)(b);
```

  __Examples
```asm
FRND.F32 R0, -|R1|;
```

__DefOpcode FRND_R : [FRND]
  __Encoding
    field<8,  4> SType stype==R;
    field<32, 8> Reg rb;
    field<96, 1> SignModi rb.neg=False;
    field<97, 1> SignModi rb.abs=False;

    field<82, 1> HSel rb.hsel=H0;
  __OperandInfo
    InList<pg, rb>;
    OutList<rd>;
    Order<pg, rd, rb>;
    Bitwidth<rd> = 32;
    Bitwidth<rb> = 32;
  __Exception
    EncodingError<IllegalBitFieldCombination, "Invalid hsel for FRND with srctype=F32."> = (ftype=="F32") and (rb.hsel=="H1");

__DefOpcode FRND_U : [FRND]
  __Encoding
    field<8,  4> SType stype==U;
    field<32, 6> UReg urb;
    field<96, 1> SignModi urb.neg=False;
    field<97, 1> SignModi urb.abs=False;

    field<82, 1> HSel urb.hsel=H0;
  __OperandInfo
    InList<pg, urb>;
    OutList<rd>;
    Order<pg, rd, urb>;
    Bitwidth<rd> = 32;
    Bitwidth<urb> = 32;
  __Exception
    EncodingError<IllegalBitFieldCombination, "Invalid hsel for FRND with srctype=F32."> = (ftype=="F32") and (urb.hsel=="H1");

__DefOpcode FRND_C : [FRND]
  __Encoding
    field<8,  4> SType stype==C;
    field<32, 22> CMem vb;
    field<96, 1> SignModi vb.neg=False;
    field<97, 1> SignModi vb.abs=False;

    field<82, 1> HSel vb.hsel=H0;
  __OperandInfo
    InList<pg, vb>;
    OutList<rd>;
    Order<pg, rd, vb>;
    Bitwidth<rd> = 32;
    Bitwidth<vb> = 32;
  __Exception
    EncodingError<IllegalBitFieldCombination, "Invalid hsel for FRND with srctype=F32."> = (ftype=="F32") and (vb.hsel=="H1");

__DefOptype F2FP : [CVT]
  __Encoding
    field<0,  8> Optype optype==F2FP;
    field<24, 8> Reg ra;

    field<80, 1> SATFINITE satf=NoSATFINITE;
    field<81, 1> RELU relu=NoRELU;

    field<88, 4> F2FPDstType dsttype;
    field<92, 4> F2FPSrcType srctype;

  __OperandInfo
    ModiOrder<dsttype, srctype>;

  __Exception
    EncodingError<IllegalBitFieldCombination, "Invalid F2FP.dst.src combination."> = not ((dsttype=="BF16" and srctype=="E8") or (dsttype=="BF16" and srctype=="F32") or (dsttype=="E2M1" and srctype=="F32") or (dsttype=="E2M3" and srctype=="F32") or (dsttype=="E3M2" and srctype=="F32") or (dsttype=="E4M3" and srctype=="F16") or (dsttype=="E4M3" and srctype=="F32") or (dsttype=="E5M2" and srctype=="F16") or (dsttype=="E5M2" and srctype=="F32") or (dsttype=="E8" and srctype=="BF16") or (dsttype=="E8" and srctype=="F32") or (dsttype=="F16" and srctype=="E2M1") or (dsttype=="F16" and srctype=="E2M3") or (dsttype=="F16" and srctype=="E3M2") or (dsttype=="F16" and srctype=="E4M3") or (dsttype=="F16" and srctype=="E5M2") or (dsttype=="F16" and srctype=="F32") or (dsttype=="TF32" and srctype=="F32") );

__DefOpcode F2FP_RRR : [F2FP]
  __Encoding
    field<8,  4> SType stype==RRR;
    field<32, 8> Reg rb;
    field<64, 8> Reg rc;
    field<84, 1> HSel rc.hsel=H0;
    field<82, 2> VSel rb.vsel = S0;
  __OperandInfo
    InList<pg, ra, rb, rc>;
    OutList<rd>;
    Order<pg, rd, ra, rb, rc>;
    Bitwidth<rd> = 32;
    Bitwidth<ra> = 32;
    Bitwidth<rb> = 32;
    Bitwidth<rc> = 32;
    AsmFormat<rb.vsel> = CvtVPSel(rb.vsel, srctype);

__DefOpcode F2FP_RUR : [F2FP]
  __Encoding
    field<8,  4> SType stype==RUR;
    field<32, 6> UReg urb;
    field<64, 8> Reg rc;
    field<84, 1> HSel rc.hsel=H0;
    field<82, 2> VSel urb.vsel = S0;
  __OperandInfo
    InList<pg, ra, urb, rc>;
    OutList<rd>;
    Order<pg, rd, ra, urb, rc>;
    Bitwidth<rd> = 32;
    Bitwidth<ra> = 32;
    Bitwidth<urb> = 32;
    Bitwidth<rc> = 32;
    AsmFormat<urb.vsel> = CvtVPSel(urb.vsel, srctype);

__DefOpcode F2FP_RIR : [F2FP]
  __Encoding
    field<8,  4> SType stype==RIR;
    field<32, 32> F32Imm vb;
    field<64, 8> Reg rc;
    field<84, 1> HSel rc.hsel=H0;
  __OperandInfo
    InList<pg, ra, vb, rc>;
    OutList<rd>;
    Order<pg, rd, ra, vb, rc>;
    Bitwidth<rd> = 32;
    Bitwidth<ra> = 32;
    Bitwidth<vb> = 32;
    Bitwidth<rc> = 32;
    AsmFormat<vb> = CvtFImm(vb, srctype);

__DefOpcode F2FP_RCR : [F2FP]
  __Encoding
    field<8,   4> SType  stype==RCR;
    field<32, 22> CMem vb;
    field<64, 8> Reg rc;
    field<82, 2> VSel vb.vsel = S0;
    field<84, 1> HSel rc.hsel=H0;
  __OperandInfo
    InList<pg, ra, vb, rc>;
    OutList<rd>;
    Order<pg, rd, ra, vb, rc>;
    Bitwidth<rd> = 32;
    Bitwidth<ra> = 32;
    Bitwidth<vb> = 32;
    Bitwidth<rc> = 32;
    AsmFormat<vb.vsel> = CvtVPSel(vb.vsel, srctype);

__DefOptype F2IP : [CVT]
  __Encoding
    field<0,  8> Optype optype==F2IP;
    field<24, 8> Reg ra;
    field<64, 8> Reg rc;

    field<77, 1> F2INTZ ntz=NoNTZ;
    field<78, 2> F2IRnd rnd=ROUND;
    field<81, 1> RELU relu=NoRELU;

    field<84, 1> HSel rc.hsel=H0;

    field<88, 1> I8Types i8type;
    field<92, 2> FTypes ftype==F32;
  
  __Syntax
```asm          
F2IP.i8type{.F32}{.NTZ}{.RELU}{.rnd} Rd, Ra, SrcB, Rc{.hsel}      $sched $req ;

.i8type = {.S8, .U8}
.rnd = {.ROUND*, .TRUNC}
.hsel = {.H0*, .H1}
```

  __Description
将2个输入F32浮点数按要求转换成8bit位宽的整数，打包（pack）后写入32bit寄存器Rd的低16bit。Rd的高16bit由Rc填充。

  __OperandInfo
Rd、Ra和Rc必须来源于GPR。

SrcB的来源可以是GPR、UR、F32Imm或cmem。

SrcC可以添加一个后缀修饰符.hsel，取值为.H0（默认值，可省略）或.H1，分别表示从Rc选取低16bit或高16bit用于填充Rd。

  __ModifierInfo
.i8type表示转换后8bit整数的类型，可以是.S8或.U8，分别表示有符号/无符号8bit整数。

输入浮点数固定为F32格式，因此修饰符.F32也可以省略。

.rnd可以是.ROUND（默认值，可省略）或.TRUNC，分别表示向最近的整数舍入（如果等距，向偶数舍入）或向零舍入。

可选修饰符.NTZ表示将输入浮点数中的NAN转换为整数0。

可选修饰符.RELU表示将转换结果的下限设置为0。当.i8type为.U8时，不能使用.RELU修饰符。

  __Semantics
```asm
F2IP.i8type.F32.ntz.relu.rnd Rd, Ra, SrcB, Rc.hsel:
    // .RELU不能在转换至.U8时使用
    assert(.i8type != .U8 || .relu != .RELU, 
           "Cannot use .RELU with .U8!");

    // 确定输出整型的表达范围
    int MININT, MAXINT;
    if (.i8type == .S8) {
        MININT = -128;
        MAXINT = 127;
    } else {
        MININT = 0;
        MAXINT = 255;
    }

    // 对输入浮点数进行转换
    for (i = 0; i < 2; i++) {
        fpVal = (i == 0) ? Ra : SrcB;
        intVal = 0;
        
        // 1. 处理输入浮点数超出表达范围的情况
        if (fpVal < MININT) {
            intVal = MININT;
        } else if (fpVal > MAXINT) {
            intVal = MAXINT;        
        // 2. 处理NAN
        } else if (isNAN(fpVal)) {
            if (.ntz == .NTZ) {
                intVal = 0;
            } else {
                intVal = (.i8type == .S8) ? -128 : 128;
            }
        // 3. 正常进行转换（根据.rnd模式进行舍入）
        } else {
            intVal = round(fpVal, .rnd);
        }
        // 4. 按需进行RELU操作
        if (.relu == .RELU && .i8type == .S8) {
            intVal = (intVal > 0) ? intVal : 0;
        }

        // 结果写入寄存器Rd
        if (i == 0) {
            // Ra的转换结果在Rd的低8bit
            Rd[7:0] = (intVal & 0xFF); 
        } else {
            // SrcB的转换结果在Rd的高8bit
            Rd[15:8]= (intVal & 0xFF);
        }
    }

    // 5. 从Rc选取16bit填充到Rd的高半字
    if (.hsel == .H0) {
        Rd[31:16]= (Rc & 0xFFFF);
    } else {
        Rd[31:16]= (Rc >> 16) & 0xFFFF;
    }
```

上述伪代码中的转换规则用自然语言描述如下：

### 输入浮点数的溢出处理

若记输出整数的表达范围为[MININ, MAXINT]，则对于Ra和SrcB:
- 若其值小于MININ（包括-inf），则转换为MININ
- 若其值大于MAXINT（包括+inf），则转换为MAXINT

转换不受.rnd定义的舍入模式控制。

### 输入NAN的特殊处理

处理输入NAN的规则具体包括：
- 若启用.NTZ，将NAN转换为0
- 否则：
    - 若.i8type为.S8，将NAN转换为-128
    - 若.i8type为.U8，将NAN转换为128

### 正常转换的处理

根据.rnd定义的舍入模式执行浮点数到整数的转换

### 按需将结果clamp为非负整数

如果启用了.RELU修饰符，则需要将上述转换结果截断到[0, MAXINT]之间。

### 将结果打包写入Rd

将Ra和Src的最终转换结果分别写入Rd的低8bit和高8bit。再根据Rc.hsel，选择Rc的低16bit或高16bit填充Rd的高16bit，得到最终的输出。

  __Examples
```asm
F2IP.U8.NTZ        R0, R1, R2, RZ   ;
F2IP.S8.F32.NTZ.RZ R0, R1, R2, R3.H1;
```

__DefOpcode F2IP_RRR : [F2IP]
  __Encoding
    field<8,  4> SType stype==RRR;
    field<32, 8> Reg rb;
  __OperandInfo
    InList<pg, ra, rb, rc>;
    OutList<rd>;
    Order<pg, rd, ra, rb, rc>;
    Bitwidth<rd> = 32;
    Bitwidth<ra> = 32;
    Bitwidth<rb> = 32;
    Bitwidth<rc> = 32;

__DefOpcode F2IP_RUR : [F2IP]
  __Encoding
    field<8,  4> SType stype==RUR;
    field<32, 6> UReg urb;
  __OperandInfo
    InList<pg, ra, urb, rc>;
    OutList<rd>;
    Order<pg, rd, ra, urb, rc>;
    Bitwidth<rd> = 32;
    Bitwidth<ra> = 32;
    Bitwidth<urb> = 32;
    Bitwidth<rc> = 32;

__DefOpcode F2IP_RCR : [F2IP]
  __Encoding
    field<8,  4> SType stype==RCR;
    field<32, 22> CMem vb;
  __OperandInfo
    InList<pg, ra, vb, rc>;
    OutList<rd>;
    Order<pg, rd, ra, vb, rc>;
    Bitwidth<rd> = 32;
    Bitwidth<ra> = 32;
    Bitwidth<vb> = 32;
    Bitwidth<rc> = 32;

__DefOpcode F2IP_RIR : [F2IP]
  __Encoding
    field<8,  4> SType stype==RIR;
    field<32, 32> F32Imm vb;
  __OperandInfo
    InList<pg, ra, vb, rc>;
    OutList<rd>;
    Order<pg, rd, ra, vb, rc>;
    Bitwidth<rd> = 32;
    Bitwidth<ra> = 32;
    Bitwidth<vb> = 32;
    Bitwidth<rc> = 32;
